home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 6 / FM Towns Free Software Collection 6.iso / game / thomas / thomas.c < prev    next >
Text File  |  1993-07-08  |  13KB  |  535 lines
  1. /**/
  2.  
  3. #include <stdio.h>
  4. #include <egb.h>
  5. #include <mos.h>
  6. #include <snd.h>
  7. #include <ctype.h>
  8. #include <string.h>
  9. #include <stdlib.h>
  10.  
  11. #define COLMOS 14
  12. #define COLWAK 32767
  13. #define COLMEN 8
  14. #define FILNLEN 128
  15. #define GAMXSZ 240
  16. #define GAMYSZ 240
  17. #define SPXMAX 25
  18. #define SPYMAX 25
  19. #define STEP    8
  20. #define DIRRIGHT  1
  21. #define DIRUP     2
  22. #define DIRLEFT   3
  23. #define DIRDOWN   4
  24. #define COMNOT    0
  25. #define COMMOV    1
  26. #define ABS(x) ((x)>0?(x):-(x))
  27. #define SndWorkSize 16384
  28. #define SNDDATASZ   64*1024
  29.  
  30. static char gwork[EgbWorkSize];
  31. static char mwork[MosWorkSize]; 
  32. static char swork[SndWorkSize];
  33. static char snddata1[SNDDATASZ];
  34. static char snddata2[SNDDATASZ];
  35. static char sndname1[FILNLEN]="thomas1.snd";
  36. static char sndname2[FILNLEN]="thomas2.snd";
  37. static char tifname[FILNLEN]="thomas.tif"; /* default tif file name */
  38. static int  moshs=0,moshe=638,mosvs=0,mosve=478;
  39. static char ramdata[GAMXSZ*GAMYSZ*2];
  40. static int  spx=4, spy=4, dotx, doty, datasize;
  41. static int  dir,rank,com;
  42. static char map[SPYMAX][SPXMAX];
  43. static int  runflag=1;
  44.  
  45. /**/
  46. int main(int argc, char *argv[])
  47. {
  48.  option(argc,argv);
  49.  screen();
  50.  loadtif();
  51.  loadsnd();
  52.  mkmap();
  53.  main_process();
  54.  end();
  55.  return 0;
  56. }
  57.  
  58. /**/
  59. main_process()
  60. {
  61.  int mb,mx,my;
  62.  while( runflag )
  63.   {
  64.   MOS_rdpos(&mb,&mx,&my);
  65.   switch(mb)
  66.    {
  67.    case 0: break;
  68.    case 1: 
  69.            switch(getmos1(mx,my))
  70.            {
  71.            case COMMOV:movmap();
  72.                        movpic();
  73.                        break; 
  74.           /*     case COMEND:runflag=0;break; */
  75.            }
  76.            break;
  77.    case 2: 
  78.            sndgo(20);
  79.            printhelp(mx,my);
  80.            break;
  81.    case 3: runflag=0; break;
  82.    default: break;
  83.    }
  84.   }
  85.  return 0;
  86. }
  87.  
  88. /**/
  89. option(int argc, char *argv[])
  90. {
  91.  int i,j,l;
  92.  char s[FILNLEN+1];
  93.  
  94.  for(i=1;i<argc;i++)
  95.   {
  96.   l=strlen(argv[i]);for(j=0;j<=l;j++) s[j]=tolower(argv[i][j]);
  97.   if( *s == '-' ) {option_size( argv[i] ); }
  98.   if( s[l-4]=='.' && s[l-3]=='t' && s[l-2]=='i' && s[l-1]=='f' )
  99.                   {strcpy(tifname,s); }
  100.   if( s[l-4]=='.' && s[l-3]=='s' && s[l-2]=='n' && s[l-1]=='d' )
  101.                   {strcpy(sndname2,sndname1);strcpy(sndname1,s); }
  102.   }
  103.  return 0;
  104. }
  105.  
  106. option_size(char *s)
  107. { 
  108.  int sz;
  109.  sz=atoi(++s);
  110.  if(sz>16) sz=16;
  111.  if(sz< 3) sz= 3;
  112.  spx=spy=sz;
  113.  return 0;
  114. }
  115.  
  116. loadsnd()
  117. {
  118.  FILE *fp;
  119.  if( (fp=fopen(sndname1,"rb"))!=NULL) 
  120.   { fread(snddata1,sizeof(char),SNDDATASZ,fp); 
  121.     if(DWORD(snddata1+12)>SNDDATASZ) DWORD(snddata1+12)=SNDDATASZ;
  122.     fclose(fp);}
  123.  if( (fp=fopen(sndname2,"rb"))!=NULL) 
  124.   { fread(snddata2,sizeof(char),SNDDATASZ,fp); 
  125.     if(DWORD(snddata2+12)>SNDDATASZ) DWORD(snddata2+12)=SNDDATASZ;
  126.     fclose(fp);}
  127.  return 0;
  128. }
  129. /**/
  130. sndgo(int n)
  131. {
  132. SND_pcm_play_stop(71);
  133. switch(n)
  134.   {
  135.    case  0:    SND_pcm_play(71,snddata1[28],127,snddata1);break;
  136.    case  1:    SND_pcm_play(71,snddata2[28],127,snddata2);break;
  137.    case 20:    SND_pcm_play(71,snddata2[28]+50,127,snddata2);break;
  138.    default:    break;
  139.   }
  140. return 0;
  141. }
  142. /**/
  143. end()
  144. {
  145.  MOS_end();
  146.  SND_end();
  147.  return 0;
  148. }
  149.  
  150. /**/
  151. screen()
  152. {
  153.  EGB_init(gwork,EgbWorkSize);   /* 画面初期化 */
  154.  EGB_resolution(gwork,0,3);     /* page=0;mode */
  155.  EGB_writePage(gwork,0);
  156.  EGB_displayStart(gwork,0,0,0); /* 表示開始位置 (0,0) */
  157.  EGB_displayStart(gwork,1,0,0); /* 仮想画面の表示位置 */
  158.  EGB_displayStart(gwork,2,1,1); /* 拡大 */
  159.  EGB_displayStart(gwork,3,640,480); /* 画面のサイズ */
  160.  
  161.  EGB_resolution(gwork,1,10);     /* page=1;mode */
  162.  EGB_writePage(gwork,1);
  163.  EGB_displayStart(gwork,0,0,0); /* 表示開始位置 (0,0) */
  164.  EGB_displayStart(gwork,1,0,0); /* 仮想画面の表示位置 */
  165.  EGB_displayStart(gwork,2,2,2); /* 拡大 */
  166.  EGB_displayStart(gwork,3,320,240); /* 画面のサイズ */
  167.  EGB_displayPage(gwork,0,3);        /* page0 前 page1,2表示 */
  168.  
  169.  SND_init(swork);
  170. /* SND_elevol_all_mute(0); */
  171.  SND_elevol_mute(1);
  172.  SND_pcm_mode_set(1);
  173.  MOS_start(mwork,MosWorkSize);
  174.  MOS_color(0,COLMOS);
  175.  MOS_horizon(moshs,moshe);
  176.  MOS_vertical(mosvs,mosve);
  177.  MOS_disp(1);
  178.  MOS_disp(3);
  179.  return 0;
  180. }
  181.  
  182. /**/
  183. loadtif()
  184. {
  185.  N_tifLoad( tifname,1,0,0);
  186.  return 0;
  187. }
  188.  
  189. /**/
  190. mkmap()
  191. {
  192.   int i,j,k;
  193.   dotx=GAMXSZ/spx; doty=GAMYSZ/spy;
  194.   datasize=dotx*doty*2;
  195.   char *ramp=ramdata;
  196.   for(j=0;j<spy;j++) for(i=0;i<spx;i++)
  197.   { k=j*spx+i;
  198.     map[j][i]=k;
  199.     N_getBlock( ramp, i*dotx, j*doty, (i+1)*dotx-1, (j+1)*doty-1);
  200.     ramp+=datasize;
  201.   }  
  202.  printmap();
  203.  return 0;
  204. }
  205.  
  206. /**/
  207. struct TIFTAG{
  208.          long  tagtype;
  209.          long  length;
  210.          long  value;
  211.         } ;
  212.  
  213. /**/
  214. N_tifLoad(char *filename,int page, int x, int y)
  215. {
  216. #define TIFWORKSIZE (320*240*2+0x0200)
  217.  char buf[TIFWORKSIZE];
  218.  struct TIFTAG * tag;
  219.  int   i,ret;
  220.  int   tagnum=0,sizex=0,sizey=0,doffs=0x0200;
  221.  
  222.  ret=N_fload(filename, buf, TIFWORKSIZE);
  223.  tagnum=(int) WORD(buf+0x0008);
  224.  tag=(struct TIFTAG *) (buf+0x000a);
  225.  for(i=0;i<tagnum;i++)
  226.   {
  227.   switch(tag->tagtype)
  228.     {
  229.     case 0x00030100:  sizex=tag->value; 
  230.                       break;
  231.     case 0x00030101:  sizey=tag->value;
  232.                       break;
  233.     case 0x00040111:  doffs=tag->value; 
  234.                       break;
  235.     default:          break;
  236.     }
  237.   tag++;
  238.   }
  239.  EGB_writePage(gwork,page);
  240.  EGB_writeMode(gwork,0);
  241.  N_putBlock( &buf[doffs], x, y, x+sizex-1, y+sizey-1);
  242.  return ret; 
  243. }
  244.  
  245. /**/
  246. int N_fload(char *fname, char *buf, int bufsize)
  247. {
  248.  FILE *fp1;
  249.  size_t fsize;
  250.  
  251.  fp1=fopen(fname, "rb");
  252.  if (fp1==NULL) {  fclose(fp1);  return(-1); }
  253.  fsize=fread(buf, 1, bufsize, fp1);
  254.  fclose(fp1);
  255.  return((int) fsize);
  256. }
  257.  
  258. /**/
  259. int N_putBlock( char *ptn, int sx, int sy, int ex, int ey)
  260. {
  261.  char gpara[14];
  262.  DWORD(gpara)=(unsigned int ) ptn;
  263.  WORD(gpara+4)=0x14;
  264.  WORD(gpara+6)=sx;
  265.  WORD(gpara+8)=sy;
  266.  WORD(gpara+10)=ex;
  267.  WORD(gpara+12)=ey;
  268.  return(EGB_putBlock(gwork,0,gpara));
  269. }
  270.  
  271. /**/
  272. int N_getBlock( char *ptn, int sx, int sy, int ex, int ey)
  273. {
  274.  char gpara[14];
  275.  DWORD(gpara)=(unsigned int ) ptn;
  276.  WORD(gpara+4)=0x14;
  277.  WORD(gpara+6)=sx;
  278.  WORD(gpara+8)=sy;
  279.  WORD(gpara+10)=ex;
  280.  WORD(gpara+12)=ey;
  281.  return(EGB_getBlock(gwork,gpara));
  282. }
  283.  
  284. getmos1(int x, int y)
  285. {
  286.   int eb, ex, ey;
  287.   dir=0;
  288.   com=COMNOT;
  289.   while(MOS_rdpos(&eb,&ex,&ey),eb==1);
  290.   switch(eb)
  291.    {
  292.    case 0: 
  293.            if(x<GAMXSZ*2 && y< GAMYSZ*2) {getdir(x,y,ex,ey);com=COMMOV;}
  294.            
  295.            break;
  296.    case 1: break;
  297.    case 2: break;
  298.    case 3: runflag=0; return com;
  299.    default: break;
  300.    }
  301.   return com;
  302. }
  303. /**/
  304. getdir(int x, int y, int ex, int ey)
  305. {
  306.  int wx, wy, ws, wt;
  307.  wx=ABS(ex-x); wy=ABS(ey-y); 
  308.  if( wx < 5 && wy < 5 )
  309.   {
  310.    wx=x-GAMXSZ; wy=y-GAMYSZ; 
  311.    ws=wx-wy; wt=wx+wy;
  312.    if( ws>=0 && wt>=0 ) dir=DIRRIGHT; /* right */
  313.    if( ws>=0 && wt<=0 ) dir=DIRUP   ; /* up    */
  314.    if( ws<=0 && wt<=0 ) dir=DIRLEFT ; /* left  */
  315.    if( ws<=0 && wt>=0 ) dir=DIRDOWN ; /* down  */
  316.   }
  317.  else 
  318.   {
  319.    wx=ex-x; wy=ey-y; 
  320.    ws=wx-wy; wt=wx+wy;
  321.    if( ws>=0 && wt>=0 ) dir=DIRRIGHT; /* right */
  322.    if( ws>=0 && wt<=0 ) dir=DIRUP   ; /* up    */
  323.    if( ws<=0 && wt<=0 ) dir=DIRLEFT ; /* left  */
  324.    if( ws<=0 && wt>=0 ) dir=DIRDOWN ; /* down  */
  325.   }
  326.  switch(dir)
  327.  {
  328.  case DIRRIGHT:rank=y/doty/2;break;
  329.  case DIRUP   :rank=x/dotx/2;break;
  330.  case DIRLEFT :rank=y/doty/2;break;
  331.  case DIRDOWN :rank=x/dotx/2;break;
  332.  }
  333.  return 0;
  334. }
  335. /**/
  336. movmap()
  337. {
  338.  int i,stnx,stny;
  339.  char xyb;
  340.  stnx=spx/3;
  341.  stny=spy/3;
  342.  switch(dir)
  343.  {
  344.  case DIRRIGHT:
  345.          if( rank<stny || spy-rank <= stny) return -1;
  346.          xyb=map[rank][spx-1];
  347.          for(i=spx-1;i>0;--i) map[rank][i]=map[rank][i-1];
  348.          map[rank][i]=xyb;
  349.          break;
  350.  case DIRUP:
  351.          if( rank<stnx || spx-rank <= stnx) return -1;
  352.          xyb=map[0][rank];
  353.          for(i=0;i<spy-1;i++) map[i][rank]=map[i+1][rank];
  354.          map[i][rank]=xyb;
  355.          break;
  356.  case DIRLEFT:
  357.          if( rank<stny || spy-rank <= stny) return -1;
  358.          xyb=map[rank][0];
  359.          for(i=0;i<spx-1;i++) map[rank][i]=map[rank][i+1];
  360.          map[rank][i]=xyb;
  361.          break;
  362.  case DIRDOWN:
  363.          if( rank<stnx || spx-rank <= stnx) return -1;
  364.          xyb=map[spy-1][rank];
  365.          for(i=spy-1;i>0;--i) map[i][rank]=map[i-1][rank];
  366.          map[i][rank]=xyb;
  367.          break;
  368.  }
  369.  return 0;
  370. }
  371. movpic()
  372. {
  373.  int x1,y1,x2,y2,stnx,stny;
  374.  char para[64],buf[320*240*2];
  375.  stnx=spx/3;
  376.  stny=spy/3;
  377.  EGB_writePage(gwork,1);
  378.  if( rank<=0 ) goto error1;
  379.  switch(dir)
  380.  {
  381.  case DIRRIGHT:
  382.          if( rank<stny || spy-rank <= stny) goto error1;
  383.            { 
  384.              sndgo(0);
  385.              x1=(spx-1)*dotx;x2=x1+dotx-1;y1=rank*doty;y2=y1+doty-1; 
  386.              N_getBlock( buf, x1,y1,x2,y2);
  387.              WORD(para+0)=0;
  388.              WORD(para+2)=y1;
  389.              WORD(para+4)=x2;
  390.              WORD(para+6)=y2;
  391.              EGB_partScroll(gwork,0,dotx,0,para);
  392.              x1=0;x2=dotx-1; 
  393.              N_putBlock( buf,x1,y1,x2,y2);
  394.            }
  395.         break;
  396.  case DIRUP:
  397.          if( rank<stnx || spx-rank <= stnx) goto error1;
  398.            {
  399.              sndgo(0);
  400.              x1=rank*dotx;x2=x1+dotx-1;y1=0;y2=doty-1; 
  401.              N_getBlock( buf, x1,y1,x2,y2);
  402.              y1=(spy-1)*doty;y2=y1+doty-1; 
  403.              WORD(para+0)=x1;
  404.              WORD(para+2)=0;
  405.              WORD(para+4)=x2;
  406.              WORD(para+6)=y2;
  407.              EGB_partScroll(gwork,0,0,-doty,para);
  408.              N_putBlock( buf,x1,y1,x2,y2);
  409.            }
  410.          break;
  411.  case DIRLEFT:
  412.          if( rank<stny || spy-rank <= stny) goto error1;
  413.            {
  414.              sndgo(0);
  415.              x1=0;x2=dotx-1;y1=rank*doty;y2=y1+doty-1; 
  416.              N_getBlock( buf, x1,y1,x2,y2);
  417.              x1=(spx-1)*dotx;x2=x1+dotx-1; 
  418.              WORD(para+0)=0;
  419.              WORD(para+2)=y1;
  420.              WORD(para+4)=x2;
  421.              WORD(para+6)=y2;
  422.              EGB_partScroll(gwork,0,-dotx,0,para);
  423.              N_putBlock( buf,x1,y1,x2,y2);
  424.            }
  425.          break;
  426.  case DIRDOWN:
  427.          if( rank<stnx || spx-rank <= stnx) goto error1;
  428.            { 
  429.              sndgo(0);
  430.              x1=rank*dotx;x2=x1+dotx-1;y1=(spy-1)*doty;y2=y1+doty-1; 
  431.              N_getBlock( buf, x1,y1,x2,y2);
  432.              WORD(para+0)=x1;
  433.              WORD(para+2)=0;
  434.              WORD(para+4)=x2;
  435.              WORD(para+6)=y2;
  436.              EGB_partScroll(gwork,0,0,doty,para);
  437.              y1=0;y2=doty-1; 
  438.              N_putBlock( buf,x1,y1,x2,y2);
  439.            }
  440.          break;
  441.  }
  442.  return 0;
  443. error1:
  444.  sndgo(1);return -1;
  445. }
  446.  
  447. printmap()
  448. {
  449.  int i,j;
  450.  char *ramp=ramdata;
  451.   for(j=0;j<spy;j++) for(i=0;i<spx;i++)
  452.   { int x1,x2,y1,y2;
  453.     ramp=ramdata+datasize*map[j][i];
  454.     x1=i*dotx;y1=j*doty;x2=x1+dotx-1;y2=y1+doty-1;
  455.     EGB_writePage(gwork,1);
  456.     N_putBlock( ramp, x1, y1, x2, y2);
  457.     rectangle( x1,y1,x2,y2,0,COLWAK);
  458.   }  
  459.  {
  460.  int stnx=spx/3,stny=spy/3;
  461.  char hat[]={0xff,0x00,0xff,0x00};
  462.  EGB_writePage(gwork,0);
  463.  EGB_hatchingPattern(gwork,2,1,4,hat);
  464.  EGB_paintMode(gwork,0x82);
  465.  EGB_color(gwork,2,COLMEN);
  466.  rectangle( 0,               0,stnx*dotx-1,  stny*doty-1, 0,COLWAK);
  467.  rectangle( 0, (spy-stny)*doty, stnx*dotx-1, spy*doty-1,  0,COLWAK);
  468.  rectangle( (spx-stnx)*dotx, 0, spx*dotx-1,  stny*doty-1, 0,COLWAK);
  469.  rectangle( (spx-stnx)*dotx,(spy-stny)*doty, spx*dotx-1, spy*doty-1, 0,COLWAK);
  470.  EGB_paintMode(gwork,0x02);
  471.  }
  472.  return 0;
  473. }
  474.  
  475. rectangle(int x1, int y1, int x2, int y2, int page, int color)
  476. {
  477.  MOS_disp(2);
  478.  char para[64];
  479.  EGB_writePage(gwork,page);
  480.  EGB_color(gwork,0,color);
  481.  WORD(para+0)=x1*2;
  482.  WORD(para+2)=y1*2;
  483.  WORD(para+4)=x2*2+1;
  484.  WORD(para+6)=y2*2+1;
  485.  EGB_rectangle(gwork,para);
  486.  MOS_disp(3);
  487.  return 0;
  488. }
  489.  
  490. sjisStringCall(int x, int y, char *str)
  491. {
  492.   char para[64];
  493.   WORD(para+0)=x;
  494.   WORD(para+2)=y+20;
  495.   WORD(para+4)=strlen(str);
  496.   strcpy(para+6,str);
  497.   MOS_disp(2);
  498.   EGB_sjisString(gwork,para);
  499.   MOS_disp(3);
  500.   return 0;
  501. }
  502.  
  503. printhelp(int mx, int my)
  504. {
  505.   char buf[TIFWORKSIZE];
  506.   int x1,y1,x2,y2,btn,x,y;
  507.   if( mx < 0 ) { x1= 0,x2=x1+320; }
  508.     else if(mx>639-320) {x2=639,x1=x2-320;}
  509.       else { x1=mx,x2=x1+320;}
  510.   if( my < 0 ) { y1= 0,y2=y1+164; }
  511.     else if(my>479-164) {y2=479,y1=y2-164;}
  512.       else { y1=my,y2=y1+164;}
  513.   EGB_writePage(gwork,0);
  514.   MOS_disp(2);
  515.   N_getBlock( buf, x1, y1, x2, y2);
  516.   MOS_disp(3);
  517.   EGB_writeMode(gwork,0);
  518.   EGB_paintMode(gwork,0x22);
  519.   rectangle( x1/2+1, y1/2+1, x2/2-1, y2/2-1, 0, 13);
  520.   EGB_color(gwork,0,15);
  521.   sjisStringCall(x1+16,y1    ,"　＝＝操作説明＝＝");
  522.   sjisStringCall(x1+16,y1+ 20,"［左ボタンをドラッグする］");
  523.   sjisStringCall(x1+16,y1+ 40,"　　　　ドラッグした方向に絵が動く。");
  524.   sjisStringCall(x1+16,y1+ 60,"　　　　ただし、角の絵は動かせない。");
  525.   sjisStringCall(x1+16,y1+ 80,"［右ボタンを押し続ける］");
  526.   sjisStringCall(x1+16,y1+100,"　　　　操作説明画面が表示される。");
  527.   sjisStringCall(x1+16,y1+120,"［左右ボタン両方を押す］");
  528.   sjisStringCall(x1+16,y1+140,"　　　　終了する。");
  529.   while(MOS_rdpos(&btn,&x,&y),btn==2);
  530.   MOS_disp(2);
  531.   N_putBlock( buf, x1, y1, x2, y2);
  532.   MOS_disp(3);
  533.   return 0;
  534. }
  535.